law of leaky abstraction

All non-trivial abstractions, to some degree, are leaky.

All non-trivial abstractions are leaky to some degree.

Lots of concrete examples in the book.

It's an article from 2002, but it fits in with the current "age of AI writing programs that are now a reality" in 2024.

Code generation tools which pretend to abstract out something, like all abstractions, leak, and the only way to deal with the leaks competently is to learn about how the abstractions work and what they are abstracting. So the abstractions save us time working, but they don’t save us time learning.

Code generation tools that pretend to abstract something leak just like any other abstraction. And the only way to properly handle leaks is to learn how abstractions work and what they abstract. In other words, abstractions save time working, but they do not save time learning.

And all this means that paradoxically, even as we have higher and higher level programming tools with better and better abstractions, becoming a proficient programmer is getting harder and harder.

And all of this means, paradoxically, that it is increasingly difficult to become a skilled programmer, despite increasingly > higher-level programming tools with better abstractions.

This is because the lower layers are less visible, hidden by the abstraction layer

Before abstraction, things that you would naturally see in the course of doing your daily work are no longer visible due to abstraction.

But "mastery" can only come through an understanding of the abstraction itself.

And while these great tools, like modern OO forms-based languages, let us get a lot of work done incredibly quickly, suddenly one day we need to figure out a problem where the abstraction leaked, and it takes 2 weeks.

These excellent tools, such as modern object-oriented form-based languages, can do a lot of work incredibly quickly, but then one day you need to figure out a problem with a leaky abstraction, and that takes two weeks.

---